#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
对比场景A和场景B的ABI使用差异

功能：
1. 分别分析场景A（官方phosphor-*）和场景B（厂商fork）
2. 对比两个场景的使用差异
3. 生成对比报告

使用方法：
    python3 compare_scenarios.py
"""

import json
import sys
from pathlib import Path
from collections import Counter

try:
    import pandas as pd
    import openpyxl
    from openpyxl.styles import Font, PatternFill, Alignment
    HAS_EXCEL = True
except ImportError:
    HAS_EXCEL = False

# 导入usage_analyzer
sys.path.insert(0, str(Path(__file__).parent))
from usage_analyzer import UsageAnalyzer


def compare_scenarios():
    """对比两个场景"""
    project_root = Path(__file__).parent.parent.parent
    abi_dir = project_root / 'output' / 'analyzed'
    
    # 场景A: OpenBMC官方phosphor项目
    print("=" * 80)
    print("场景A: OpenBMC官方phosphor-*项目分析")
    print("=" * 80)
    
    repos_a = project_root / 'config' / 'repos_scenario_a.txt'
    output_a = project_root / 'output' / 'usage_scenario_a.xlsx'
    
    analyzer_a = UsageAnalyzer(str(abi_dir), str(repos_a))
    analyzer_a.analyze_repos()
    analyzer_a.generate_report(str(output_a))
    
    # 场景B: 厂商公开fork
    print("\n" + "=" * 80)
    print("场景B: 厂商公开OpenBMC Fork分析")
    print("=" * 80)
    
    repos_b = project_root / 'config' / 'repos_scenario_b.txt'
    output_b = project_root / 'output' / 'usage_scenario_b.xlsx'
    
    analyzer_b = UsageAnalyzer(str(abi_dir), str(repos_b))
    analyzer_b.analyze_repos()
    analyzer_b.generate_report(str(output_b))
    
    # 生成对比报告
    print("\n" + "=" * 80)
    print("生成场景对比报告")
    print("=" * 80)
    
    generate_comparison_report(analyzer_a, analyzer_b, project_root / 'output' / 'usage_comparison.xlsx')


def generate_comparison_report(analyzer_a: UsageAnalyzer, analyzer_b: UsageAnalyzer, output_path: Path):
    """生成对比报告"""
    
    if not HAS_EXCEL:
        print("[ERROR] 需要安装pandas和openpyxl")
        return
    
    # 准备对比数据
    comparison_data = []
    
    all_functions = set(analyzer_a.functions.keys()) | set(analyzer_b.functions.keys())
    
    for func_name in all_functions:
        if func_name not in analyzer_a.functions:
            continue
            
        func_info = analyzer_a.functions[func_name]
        
        count_a = analyzer_a.usage_stats.get(func_name, 0)
        count_b = analyzer_b.usage_stats.get(func_name, 0)
        
        repos_a = len(analyzer_a.usage_details.get(func_name, {}).get('repos', set()))
        repos_b = len(analyzer_b.usage_details.get(func_name, {}).get('repos', set()))
        
        comparison_data.append({
            '函数名': func_name,
            '库': func_info['library'],
            '命名空间': func_info['namespace'],
            '类': func_info['class_name'],
            '场景A使用次数': count_a,
            '场景A仓库数': repos_a,
            '场景B使用次数': count_b,
            '场景B仓库数': repos_b,
            '总使用次数': count_a + count_b,
            '场景差异': abs(count_a - count_b),
            '主要场景': 'A' if count_a > count_b else ('B' if count_b > count_a else '相同')
        })
    
    df = pd.DataFrame(comparison_data)
    
    # 保存到Excel
    output_path.parent.mkdir(parents=True, exist_ok=True)
    
    with pd.ExcelWriter(output_path, engine='openpyxl') as writer:
        # Sheet 1: 完整对比
        df_sorted = df.sort_values('总使用次数', ascending=False)
        df_sorted.to_excel(writer, sheet_name='完整对比', index=False)
        
        # Sheet 2: 仅场景A使用（官方标准用法）
        df_only_a = df[df['场景A使用次数'] > df['场景B使用次数']].sort_values('场景A使用次数', ascending=False)
        df_only_a.to_excel(writer, sheet_name='场景A主导', index=False)
        
        # Sheet 3: 仅场景B使用（厂商特殊用法）
        df_only_b = df[df['场景B使用次数'] > df['场景A使用次数']].sort_values('场景B使用次数', ascending=False)
        df_only_b.to_excel(writer, sheet_name='场景B主导', index=False)
        
        # Sheet 4: 两个场景都常用（核心函数）
        df_both = df[(df['场景A使用次数'] > 10) & (df['场景B使用次数'] > 10)].sort_values('总使用次数', ascending=False)
        df_both.to_excel(writer, sheet_name='双场景核心', index=False)
        
        # Sheet 5: Top 100 总使用
        df_top100 = df_sorted.head(100)
        df_top100.to_excel(writer, sheet_name='Top100', index=False)
        
        # Sheet 6: 统计对比
        stats_data = {
            '统计项': [
                '总函数数',
                '场景A使用的函数',
                '场景B使用的函数',
                '两个场景都使用',
                '仅场景A使用',
                '仅场景B使用',
                '场景A总调用次数',
                '场景B总调用次数',
                '场景A平均每函数调用',
                '场景B平均每函数调用'
            ],
            '数值': [
                len(df),
                len(df[df['场景A使用次数'] > 0]),
                len(df[df['场景B使用次数'] > 0]),
                len(df[(df['场景A使用次数'] > 0) & (df['场景B使用次数'] > 0)]),
                len(df[(df['场景A使用次数'] > 0) & (df['场景B使用次数'] == 0)]),
                len(df[(df['场景A使用次数'] == 0) & (df['场景B使用次数'] > 0)]),
                df['场景A使用次数'].sum(),
                df['场景B使用次数'].sum(),
                f"{df[df['场景A使用次数'] > 0]['场景A使用次数'].mean():.1f}",
                f"{df[df['场景B使用次数'] > 0]['场景B使用次数'].mean():.1f}"
            ]
        }
        df_stats = pd.DataFrame(stats_data)
        df_stats.to_excel(writer, sheet_name='统计对比', index=False)
        
        # Sheet 7: 按库对比
        lib_comparison = []
        for lib in df['库'].unique():
            lib_df = df[df['库'] == lib]
            lib_comparison.append({
                '库': lib,
                '函数数': len(lib_df),
                '场景A使用': lib_df['场景A使用次数'].sum(),
                '场景B使用': lib_df['场景B使用次数'].sum(),
                '场景A占比': f"{lib_df['场景A使用次数'].sum() / df['场景A使用次数'].sum() * 100:.1f}%",
                '场景B占比': f"{lib_df['场景B使用次数'].sum() / df['场景B使用次数'].sum() * 100:.1f}%"
            })
        df_lib = pd.DataFrame(lib_comparison).sort_values('场景A使用', ascending=False)
        df_lib.to_excel(writer, sheet_name='按库对比', index=False)
    
    # 美化Excel
    _format_excel(output_path)
    
    print(f"[SUCCESS] 对比报告已生成: {output_path}")
    
    # 打印对比摘要
    _print_comparison_summary(df)


def _print_comparison_summary(df: pd.DataFrame):
    """打印对比摘要"""
    print("\n" + "=" * 80)
    print("场景对比摘要")
    print("=" * 80)
    
    total_funcs = len(df)
    used_a = len(df[df['场景A使用次数'] > 0])
    used_b = len(df[df['场景B使用次数'] > 0])
    used_both = len(df[(df['场景A使用次数'] > 0) & (df['场景B使用次数'] > 0)])
    
    print(f"总函数数: {total_funcs}")
    print(f"场景A使用: {used_a} ({used_a/total_funcs*100:.1f}%)")
    print(f"场景B使用: {used_b} ({used_b/total_funcs*100:.1f}%)")
    print(f"两者都用: {used_both} ({used_both/total_funcs*100:.1f}%)")
    
    print(f"\nTop 10 场景A高频函数:")
    top10_a = df.nlargest(10, '场景A使用次数')
    for idx, row in top10_a.iterrows():
        print(f"  {row['函数名']}: {row['场景A使用次数']}次 (B:{row['场景B使用次数']}次) - {row['库']}")
    
    print(f"\nTop 10 场景B高频函数:")
    top10_b = df.nlargest(10, '场景B使用次数')
    for idx, row in top10_b.iterrows():
        print(f"  {row['函数名']}: {row['场景B使用次数']}次 (A:{row['场景A使用次数']}次) - {row['库']}")
    
    print("\n按库统计:")
    lib_stats = df.groupby('库').agg({
        '场景A使用次数': 'sum',
        '场景B使用次数': 'sum'
    }).sort_values('场景A使用次数', ascending=False)
    
    for lib, row in lib_stats.head(10).iterrows():
        print(f"  {lib}: A={row['场景A使用次数']} B={row['场景B使用次数']}")
    
    print("=" * 80)


def _format_excel(excel_path: Path):
    """美化Excel表格"""
    wb = openpyxl.load_workbook(excel_path)
    
    header_fill = PatternFill(start_color="366092", end_color="366092", fill_type="solid")
    header_font = Font(bold=True, color="FFFFFF")
    
    for sheet in wb.worksheets:
        # 设置表头样式
        if sheet.max_row > 0:
            for cell in sheet[1]:
                cell.fill = header_fill
                cell.font = header_font
                cell.alignment = Alignment(horizontal='center', vertical='center')
        
        # 自动调整列宽
        for column in sheet.columns:
            max_length = 0
            column_letter = column[0].column_letter
            for cell in column:
                try:
                    if cell.value:
                        max_length = max(max_length, len(str(cell.value)))
                except:
                    pass
            adjusted_width = min(max_length + 2, 80)
            sheet.column_dimensions[column_letter].width = adjusted_width
    
    wb.save(excel_path)


if __name__ == '__main__':
    try:
        compare_scenarios()
        sys.exit(0)
    except Exception as e:
        print(f"[ERROR] 对比分析失败: {e}", file=sys.stderr)
        import traceback
        traceback.print_exc()
        sys.exit(1)

